"""
用户权限工具函数
提供基于角色的权限控制功能
"""
from role.models import SysUserRole, SysRole
from user.models import SysUser


def get_user_roles(user_id):
    """
    获取用户的所有角色
    :param user_id: 用户ID
    :return: 角色列表
    """
    try:
        user_roles = SysUserRole.objects.filter(user_id=user_id).select_related('role')
        return [ur.role for ur in user_roles]
    except Exception:
        return []


def get_user_role_names(user_id):
    """
    获取用户的所有角色名称
    :param user_id: 用户ID
    :return: 角色名称列表
    """
    roles = get_user_roles(user_id)
    return [role.name for role in roles]


def has_role(user_id, role_name):
    """
    检查用户是否拥有特定角色
    :param user_id: 用户ID
    :param role_name: 角色名称
    :return: True/False
    """
    role_names = get_user_role_names(user_id)
    return role_name in role_names


def is_super_admin(user_id):
    """
    检查用户是否为超级管理员
    :param user_id: 用户ID
    :return: True/False
    """
    return has_role(user_id, '超级管理员')


def is_admin(user_id):
    """
    检查用户是否为管理员（包括超级管理员和普通管理员）
    :param user_id: 用户ID
    :return: True/False
    """
    return has_role(user_id, '超级管理员') or has_role(user_id, '普通管理员')


def is_regular_user(user_id):
    """
    检查用户是否为普通用户
    :param user_id: 用户ID
    :return: True/False
    """
    return has_role(user_id, '普通用户')


def can_manage_user(operator_id, target_user_id):
    """
    检查操作者是否可以管理目标用户
    权限规则（同级别排除）：
    1. 超级管理员可以管理普通管理员和普通用户，但不能管理其他超级管理员（除了自己）
    2. 普通管理员可以管理普通用户，但不能管理超级管理员和其他普通管理员（除了自己）
    3. 普通用户只能管理自己
    
    :param operator_id: 操作者用户ID
    :param target_user_id: 目标用户ID
    :return: True/False
    """
    # 自己总是可以管理自己
    if operator_id == target_user_id:
        return True
    
    # 获取操作者和目标用户的角色
    operator_roles = get_user_role_names(operator_id)
    target_roles = get_user_role_names(target_user_id)
    
    # 超级管理员可以管理普通管理员和普通用户，但不能管理其他超级管理员
    if '超级管理员' in operator_roles:
        return '超级管理员' not in target_roles
    
    # 普通管理员可以管理普通用户，但不能管理超级管理员和其他普通管理员
    if '普通管理员' in operator_roles:
        # 不能管理超级管理员
        if '超级管理员' in target_roles:
            return False
        # 不能管理其他普通管理员
        if '普通管理员' in target_roles:
            return False
        # 可以管理普通用户
        return '普通用户' in target_roles or len(target_roles) == 0
    
    # 普通用户只能管理自己（已在前面检查）
    return False


def can_create_user_with_role(operator_id, target_role_name):
    """
    检查操作者是否可以创建指定角色的用户
    权限规则：
    1. 超级管理员可以创建普通管理员和普通用户，但不能创建超级管理员
    2. 普通管理员只能创建普通用户
    3. 普通用户不能创建任何用户
    
    :param operator_id: 操作者用户ID
    :param target_role_name: 目标角色名称
    :return: True/False
    """
    # 超级管理员可以创建普通管理员和普通用户，但不能创建超级管理员
    if is_super_admin(operator_id):
        return target_role_name in ['普通管理员', '普通用户']
    
    # 普通管理员只能创建普通用户
    if is_admin(operator_id) and target_role_name == '普通用户':
        return True
    
    # 普通用户不能创建任何用户
    return False


def get_accessible_users(operator_id):
    """
    获取操作者可以访问的用户列表
    权限规则（同级别排除）：
    1. 超级管理员可以访问普通管理员和普通用户，但不能访问其他超级管理员（除了自己）
    2. 普通管理员可以访问普通用户，但不能访问超级管理员和其他普通管理员（除了自己）
    3. 普通用户只能访问自己
    
    :param operator_id: 操作者用户ID
    :return: 用户ID列表
    """
    operator_roles = get_user_role_names(operator_id)
    
    # 超级管理员可以访问普通管理员和普通用户，但不能访问其他超级管理员
    if '超级管理员' in operator_roles:
        # 获取所有超级管理员的ID（除了自己）
        other_super_admin_ids = SysUserRole.objects.filter(
            role__name='超级管理员'
        ).exclude(user_id=operator_id).values_list('user_id', flat=True)
        
        # 返回除了其他超级管理员以外的所有用户
        accessible_users = SysUser.objects.exclude(
            id__in=other_super_admin_ids
        ).values_list('id', flat=True)
        
        return list(accessible_users)
    
    # 普通管理员可以访问普通用户，但不能访问超级管理员和其他普通管理员
    if '普通管理员' in operator_roles:
        # 获取所有超级管理员的ID
        super_admin_user_ids = SysUserRole.objects.filter(
            role__name='超级管理员'
        ).values_list('user_id', flat=True)
        
        # 获取其他普通管理员的ID（除了自己）
        other_admin_user_ids = SysUserRole.objects.filter(
            role__name='普通管理员'
        ).exclude(user_id=operator_id).values_list('user_id', flat=True)
        
        # 合并不能访问的用户ID
        excluded_user_ids = list(super_admin_user_ids) + list(other_admin_user_ids)
        
        # 返回除了超级管理员和其他普通管理员以外的所有用户（包括自己）
        accessible_users = SysUser.objects.exclude(
            id__in=excluded_user_ids
        ).values_list('id', flat=True)
        
        # 确保包含自己
        accessible_user_list = list(accessible_users)
        if operator_id not in accessible_user_list:
            accessible_user_list.append(operator_id)
        
        return accessible_user_list
    
    # 普通用户只能访问自己
    return [operator_id]


def get_user_with_roles(user_id):
    """
    获取用户信息及其角色
    :param user_id: 用户ID
    :return: 包含角色信息的用户字典
    """
    try:
        user = SysUser.objects.get(id=user_id)
        roles = get_user_role_names(user_id)
        
        return {
            'id': user.id,
            'username': user.username,
            'email': user.email,
            'first_name': user.nickname or '',
            'avatar': user.avatar,
            'is_active': user.status == 0,
            'date_joined': user.create_time.strftime('%Y-%m-%d %H:%M:%S') if user.create_time else '',
            'phonenumber': user.phonenumber,
            'status': user.status,
            'roles': roles,
            'role_display': ', '.join(roles) if roles else '无角色'
        }
    except SysUser.DoesNotExist:
        return None